package com.et114.core.utility;

/*
 * Copyright (c) 2005 Allways, LLC. All rights reserved.
 * �������� 2005-12-8
 * ���ù����๹����
 */
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;

/**
 * 字符串操作常用工具类
 * @
 * <a href="StringUtil.java.html"><b><i>View Source</i></b></a>
 *
 * @作者 daomingw
 * @版本 1.0
 */
public class StringUtil {


	/**
	 * 字符串是否包含指定字符串
	 * @param s
	 * @param text
	 * @return
	 */
	public static boolean contains(String s, String text) {
		return contains(s, text, StringPool.COMMA);
	}

	/**
	 *  字符串是否包含指定字符串
	 * @param s
	 * @param text
	 * @param delimiter
	 * @return
	 */
	public static boolean contains(String s, String text, String delimiter) {
		if ((s == null) || (text == null) || (delimiter == null)) {
			return false;
		}

		if (!s.endsWith(delimiter)) {
			s += delimiter;
		}

		int pos = s.indexOf(delimiter + text + delimiter);

		if (pos == -1) {
			if (s.startsWith(text + delimiter)) {
				return true;
			}

			return false;
		}

		return true;
	}

	/**
	 * 统计字符串s包含字符串text的个数
	 * @param s
	 * @param text  排列顺序必须与原有的字符串s排列顺序一致
	 * @return
	 */
	public static int count(String s, String text) {
		if ((s == null) || (text == null)) {
			return 0;
		}

		int count = 0;

		int pos = s.indexOf(text);

		while (pos != -1) {
			pos = s.indexOf(text, pos + text.length());
			count++;
		}

		return count;
	}

	/**
	 * 判断字符串s是否以给定的字符end结尾
	 * @param s
	 * @param end
	 * @return
	 */
	public static boolean endsWith(String s, char end) {
		return startsWith(s, (new Character(end)).toString());
	}

	/**
	 * 判断字符串s是否以给定的字符串end结尾，如果end字符串的长度
	 * 比字符串s长，返回false,
	 * @param s
	 * @param end
	 * @return
	 */
	public static boolean endsWith(String s, String end) {
		if ((s == null) || (end == null)) {
			return false;
		}

		if (end.length() > s.length()) {
			return false;
		}

		String temp = s.substring(s.length() - end.length(), s.length());

		if (temp.equalsIgnoreCase(end)) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 从字符串s中抽取字符，以原有的排列顺序排列
	 * @param s  
	 * @return  如果s为null,返回空字符串
	 * 如，String s="abc1dasf23d4f5";
	 * s=extractDigits(s);
	 * 返回abcdasfdf字符串
	 */
	public static String extractChars(String s) {
		if (s == null) {
			return "";
		}

		char[] c = s.toCharArray();

		StringBuffer sb = new StringBuffer();

		for (int i = 0; i < c.length; i++) {
			if (Validator.isChar(c[i])) {
				sb.append(c[i]);
			}
		}

		return sb.toString();
	}

	/**
	 * 从字符串s中抽取数字，以原有的排列顺序排列
	 * @param s  
	 * @return  如果s为null,返回空字符串
	 * 如，String s="abc1dasf23d4f5";
	 * s=extractDigits(s);
	 * 返回12345字符串
	 */
	public static String extractDigits(String s) {
		if (s == null) {
			return "";
		}

		char[] c = s.toCharArray();

		StringBuffer sb = new StringBuffer();

		for (int i = 0; i < c.length; i++) {
			if (Validator.isDigit(c[i])) {
				sb.append(c[i]);
			}
		}

		return sb.toString();
	}

	/**
	 * 把List里的每个字符串元素用","相连
	 * @param list
	 * @param delimiter
	 * @return
	 */
	public static String merge(List list) {
		return merge(list, StringPool.COMMA);
	}

	/**
	 * 把List里的每个字符串元素用指定的delimiter字符串相连
	 * @param list
	 * @param delimiter
	 * @return
	 */
	public static String merge(List list, String delimiter) {
		return merge((String[]) list.toArray(new String[0]), delimiter);
	}

	/**
	 * 把字符串数组里的每个元素用","相连
	 * @param array
	 * @return
	 */
	public static String merge(String array[]) {
		return merge(array, StringPool.COMMA);
	}

	/**
	* 把字符串数组里的每个元素用指定的delimiter字符串相连
	* @param array
	* @return 
	*/
	public static String merge(String array[], String delimiter) {
		if (array == null) {
			return null;
		}

		StringBuffer sb = new StringBuffer();

		for (int i = 0; i < array.length; i++) {
			sb.append(array[i].trim());

			if ((i + 1) != array.length) {
				sb.append(delimiter);
			}
		}

		return sb.toString();
	}

    /**
     * 取随机字符串,字符串中每个字符次序随机排列，产生新的字符串
     * @param s
     * @return
     */
	public static String randomize(String s) {
		Randomizer r = new Randomizer();

		return r.randomize(s);
	}

	/**
	 * 读取以ClassLoader目录为基准，指定资源文件的内容，以字符串文本输出
	 * @param classLoader
	 * @param name	资源文件的名称
	 * @return  如果资源未找到，抛出异常，返回null;
	 * @throws IOException
	 */
	public static String read(ClassLoader classLoader, String name)
		throws IOException {

		return read(classLoader.getResourceAsStream(name));
	}

	/**
	 * 读取输入流文件的内容，以字符串文本输出
	 * @param is   输入流
	 * @return     文本文件内容 
	 * @throws IOException
	 * 如果资源未找到，抛出异常，返回null;
	 */
	public static String read(InputStream is) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(is));

		StringBuffer sb = new StringBuffer();
		String line = null;

		while ((line = br.readLine()) != null) {
			sb.append(line).append('\n');
		}

		br.close();

		return sb.toString().trim();
	}

    /**
     * 用字符替换字符串s中某个字符
     * @param s
     * @param oldSub    字符串s中包含的字符，即应被替换的字符
     * @param newSub	 新的字符，用来代替原有的字符
     * @return
     */
	public static String replace(String s, char oldSub, char newSub) {
		return replace(s, oldSub, new Character(newSub).toString());
	}
    
    /**
     * 用字符串替换字符串s中某个字符
     * @param s
     * @param oldSub   字符串s中包含的字符，即应被替换的字符
     * @param newSub   新的字符串，用来代替原有的字符
     * @return
     */
	public static String replace(String s, char oldSub, String newSub) {
		if ((s == null) || (newSub == null)) {
			return null;
		}

		char[] c = s.toCharArray();

		StringBuffer sb = new StringBuffer();

		for (int i = 0; i < c.length; i++) {
			if (c[i] == oldSub) {
				sb.append(newSub);
			} else {
				sb.append(c[i]);
			}
		}

		return sb.toString();
	}
	/**
	 * 字符串中替换某个字符串
	 * @param s
	 * @param oldSub  字符串s中包含的字符串，即应被替换的字符串
	 * @param newSub  新的字符串，用来代替原有的字符串
	 * @return
	 */

	public static String replace(String s, String oldSub, String newSub) {
		if ((s == null) || (oldSub == null) || (newSub == null)) {
			return null;
		}

		int y = s.indexOf(oldSub);

		if (y >= 0) {
			StringBuffer sb = new StringBuffer();

			int length = oldSub.length();
			int x = 0;

			while (x <= y) {
				sb.append(s.substring(x, y));
				sb.append(newSub);
				x = y + length;
				y = s.indexOf(oldSub, x);
			}

			sb.append(s.substring(x));

			return sb.toString();
		} else {
			return s;
		}
	}

	/**
	 * 替换字符串s中 多个字符子串
	 * @param s
	 * @param oldSubs  字符串s中包含的字符串，即应被替换的字符串
	 * @param newSubs  新的字符串，用来代替原有的字符串
	 * @return
	 * 如，把String s="abcdefg" 中的ab替换成AB,fg替换成FG,可这样：
	 * s=StringUtil.replace(s,new String[]{"ab","fg"},new String[]{"AB","FG"});
	 * 输出s的结果为：ABcdeFG
	 */
	public static String replace(
		String s,
		String[] oldSubs,
		String[] newSubs) {
		if ((s == null) || (oldSubs == null) || (newSubs == null)) {
			return null;
		}

		if (oldSubs.length != newSubs.length) {
			return s;
		}

		for (int i = 0; i < oldSubs.length; i++) {
			s = replace(s, oldSubs[i], newSubs[i]);
		}

		return s;
	}

   /**
    * 翻转字符串的排列次序
    * @param s
    * @return
    * 如，String s="永诺信息";
    * s=reverse(s);
    * 输出为：息信诺永
    */
	public static String reverse(String s) {
		if (s == null) {
			return null;
		}

		char[] c = s.toCharArray();
		char[] reverse = new char[c.length];

		for (int i = 0; i < c.length; i++) {
			reverse[i] = c[c.length - i - 1];
		}

		return new String(reverse);
	}

	/**
	* 字符串s缩短，缩短长度默认为20,其余用".."补充
	* @param s
	* @return
	* 如，String s="永诺信息技术有限公司 技术部召开技术座谈会";
	* s=shorten(s);
	* 输出s:永诺信息技术有限公司 技术部召开技术座谈..
	*/
	public static String shorten(String s) {
		return shorten(s, 20);
	}

	/**
	 * 字符串s缩短，缩短长度为length,其余用".."补充
	 * @param s
	 * @param length  指定宽度
	 * @return
	 * 如，String s="永诺信息技术有限公司";
	 * s=shorten(s,4);
	 * 输出s:永诺信息..
	 */
	public static String shorten(String s, int length) {
		return shorten(s, length, "..");
	}
	/**
	* 字符串s缩短，默认长度为20,其余用suffix补充
	* @param s
	* @param suffix   补充后缀
	* @return
	* 如，String s="永诺信息技术有限公司 技术部召开技术座谈会";
	* s=shorten(s,".....");
	* 输出s:永诺信息技术有限公司 技术部召开技术座谈.....
	*/
	public static String shorten(String s, String suffix) {
		return shorten(s, 20, suffix);
	}

	/**
	 *  字符串s缩短，缩短长度为length,其余用suffix补充
	 * @param s  
	 * @param length 缩短长度
	 * @param suffix 补充后缀
	 * @return
	 * 如，String s="永诺信息技术有限公司 技术部召开技术座谈会";
	 * s=shorten(s,10,".....");
	 * 输出s:永诺信息技术有限公司.....
	 */
	public static String shorten(String s, int length, String suffix) {
		if (s == null || suffix == null) {
			return null;
		}

		if (s.length() > length) {
			s = s.substring(0, length) + suffix;
		}

		return s;
	}

	/**
	 * 拆分字符串，默认以","为分割符号
	 * @param s
	 * @return
	 */
	public static String[] split(String s) {
		return split(s, StringPool.COMMA);
	}

	/**
	 * 拆分字符串以delimiter字符串为分割符号
	 * @param s
	 * @param delimiter
	 * @return
	 */
	public static String[] split(String s, String delimiter) {
		if (s == null || delimiter == null) {
			return new String[0];
		}

		s = s.trim();

		if (!s.endsWith(delimiter)) {
			s += delimiter;
		}

		if (s.equals(delimiter)) {
			return new String[0];
		}

		List nodeValues = new ArrayList();

		if (delimiter.equals("\n") || delimiter.equals("\r")) {
			try {
				BufferedReader br = new BufferedReader(new StringReader(s));

				String line = null;

				while ((line = br.readLine()) != null) {
					nodeValues.add(line);
				}

				br.close();
			} catch (IOException ioe) {
				ioe.printStackTrace();
			}
		} else {
			int offset = 0;
			int pos = s.indexOf(delimiter, offset);

			while (pos != -1) {
				nodeValues.add(s.substring(offset, pos));

				offset = pos + delimiter.length();
				pos = s.indexOf(delimiter, offset);
			}
		}

		return (String[]) nodeValues.toArray(new String[0]);
	}

	/**
	 * 拆分字符串以delimiter字符串为分割符号，返回boolean数组，x为数组元素的默认值
	 * @param s
	 * @param delimiter
	 * @param x
	 * @return  如出现异常 返回默认值
	 */
	public static boolean[] split(String s, String delimiter, boolean x) {
		String[] array = split(s, delimiter);
		boolean[] newArray = new boolean[array.length];

		for (int i = 0; i < array.length; i++) {
			boolean value = x;

			try {
				value = Boolean.valueOf(array[i]).booleanValue();
			} catch (Exception e) {
			}

			newArray[i] = value;
		}

		return newArray;
	}

	/**
	 * 拆分字符串以delimiter字符串为分割符号，返回double数组，x为数组元素的默认值
	 * @param s
	 * @param delimiter
	 * @param x
	 * @return  如出现异常 返回默认值
	 */
	public static double[] split(String s, String delimiter, double x) {
		String[] array = split(s, delimiter);
		double[] newArray = new double[array.length];

		for (int i = 0; i < array.length; i++) {
			double value = x;

			try {
				value = Double.parseDouble(array[i]);
			} catch (Exception e) {
			}

			newArray[i] = value;
		}

		return newArray;
	}

	/**
	 * 拆分字符串以delimiter字符串为分割符号，返回float数组，x为数组元素的默认值
	 * @param s
	 * @param delimiter
	 * @param x
	 * @return  如出现异常 返回默认值
	 */
	public static float[] split(String s, String delimiter, float x) {
		String[] array = split(s, delimiter);
		float[] newArray = new float[array.length];

		for (int i = 0; i < array.length; i++) {
			float value = x;

			try {
				value = Float.parseFloat(array[i]);
			} catch (Exception e) {
			}

			newArray[i] = value;
		}

		return newArray;
	}
	/**
	 * 拆分字符串以delimiter字符串为分割符号，返回int数组，x为数组元素的默认值
	 * @param s
	 * @param delimiter
	 * @param x
	 * @return	如出现异常 返回默认值
	 */
	public static int[] split(String s, String delimiter, int x) {
		String[] array = split(s, delimiter);
		int[] newArray = new int[array.length];

		for (int i = 0; i < array.length; i++) {
			int value = x;

			try {
				value = Integer.parseInt(array[i]);
			} catch (Exception e) {
			}

			newArray[i] = value;
		}

		return newArray;
	}
	/**
	 * 拆分字符串以delimiter字符串为分割符号，返回long数组，x为数组元素的默认值
	 * @param s
	 * @param delimiter
	 * @param x
	 * @return  如出现异常 返回默认值
	 */    
	public static long[] split(String s, String delimiter, long x) {
		String[] array = split(s, delimiter);
		long[] newArray = new long[array.length];

		for (int i = 0; i < array.length; i++) {
			long value = x;

			try {
				value = Long.parseLong(array[i]);
			} catch (Exception e) {
			}

			newArray[i] = value;
		}

		return newArray;
	}
	/**
	 * 拆分字符串以delimiter字符串为分割符号，返回short数组，x为数组元素的默认值
	 * @param s
	 * @param delimiter
	 * @param x
	 * @return  如出现异常 返回默认值
	 */    
	public static short[] split(String s, String delimiter, short x) {
		String[] array = split(s, delimiter);
		short[] newArray = new short[array.length];

		for (int i = 0; i < array.length; i++) {
			short value = x;

			try {
				value = Short.parseShort(array[i]);
			} catch (Exception e) {
			}

			newArray[i] = value;
		}

		return newArray;
	}
    /**
     * 异常输出
     * @param t
     * @return
     */
	public static final String stackTrace(Throwable t) {
		String s = null;

		try {
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			t.printStackTrace(new PrintWriter(baos, true));
			s = baos.toString();
		} catch (Exception e) {
		}

		return s;
	}

	/**
	 * 判断字符串s是否以字符begin开头
	 * @param s
	 * @param begin
	 * @return
	 */
	public static boolean startsWith(String s, char begin) {
		return startsWith(s, (new Character(begin)).toString());
	}

	/**
	 * 判断字符串s是否以字符串start开头，如果字符串start的长度大于字符串s的长度,返回false
	 * @param s
	 * @param start
	 * @return
	 */
	public static boolean startsWith(String s, String start) {
		if ((s == null) || (start == null)) {
			return false;
		}

		if (start.length() > s.length()) {
			return false;
		}

		String temp = s.substring(0, start.length());

		if (temp.equalsIgnoreCase(start)) {
			return true;
		} else {
			return false;
		}
	}


}